#include "base_command.h"
#include "service/backend_service.h"
#include "../database/database_manager.h"
#include "command_executor.h"
#include <QDebug>
#include <QUrl>
#include <QUrlQuery>
#include <QStandardPaths>
#include <QDir>
#include <QFile>
#include <QSettings>

BaseCommand::BaseCommand(QObject *parent)
    : QObject(parent)
    , m_backendService(nullptr)
    , m_networkManager(nullptr)
    , m_databaseManager(nullptr)
    , m_isWaitingForToken(false)
{
}

BaseCommand::~BaseCommand()
{
    // 停止等待 token，避免在析构时触发回调
    m_isWaitingForToken = false;
    
    // 断开 BackendService 信号连接
    // if (m_backendService) {
    //     disconnect(m_backendService, &BackendService::exchangeAccessTokenCompleted,
    //                this, &BaseCommand::handleExchangeAccessTokenCompleted);
    // }
    
    // 清空指针，避免在析构后访问
    m_backendService = nullptr;
    m_networkManager = nullptr;
    m_databaseManager = nullptr;
}

void BaseCommand::setBackendService(BackendService *backendService)
{
    // 如果之前已经设置了 backendService，先断开旧的连接
    if (m_backendService) {
        // 断开旧的 CommandExecutor 信号连接（如果存在）
        CommandExecutor *oldCommandExecutor = m_backendService->getCommandExecutor();
        if (oldCommandExecutor) {
            disconnect(oldCommandExecutor, &CommandExecutor::exchangeAccessTokenCompleted,
                       this, &BaseCommand::handleExchangeAccessTokenCompleted);
        }
    }
    
    m_backendService = backendService;
    
    // 连接 AccessToken 获取完成信号（通过 CommandExecutor）
    // 使用 Qt::QueuedConnection 确保线程安全，避免在信号处理时对象被销毁
    if (m_backendService) {
        CommandExecutor *commandExecutor = m_backendService->getCommandExecutor();
        if (commandExecutor) {
            connect(commandExecutor, &CommandExecutor::exchangeAccessTokenCompleted,
                    this, &BaseCommand::handleExchangeAccessTokenCompleted,
                    Qt::QueuedConnection);
        }
    }
}

void BaseCommand::setNetworkAccessManager(QNetworkAccessManager *networkManager)
{
    m_networkManager = networkManager;
}

void BaseCommand::setDatabaseManager(DatabaseManager *databaseManager)
{
    m_databaseManager = databaseManager;
}

void BaseCommand::addTokenToRequest(QNetworkRequest &request, const QString &accessToken)
{
    if (!accessToken.isEmpty()) {
        request.setRawHeader("accessToken", accessToken.toUtf8());
        qDebug() << "BaseCommand: 已添加accessToken到请求头";
    } else {
        qDebug() << "BaseCommand: accessToken为空，无法添加到请求头";
    }
}

QNetworkRequest BaseCommand::createRequest(const QString &url, const QString &method, const QString &userAgent)
{
    QNetworkRequest request;
    QUrl requestUrl(url);
    QString upperMethod = method.toUpper();
    
    // 由于服务端采用 HiddenHttpMethodFilter 隐藏提交方法
    // 对于非 GET、POST 的方法，统一使用 POST 并在 URL 后添加 _method 参数
    if (upperMethod == "PUT" || upperMethod == "DELETE" || upperMethod == "PATCH") {
        // 使用 POST 方法
        request.setAttribute(QNetworkRequest::CustomVerbAttribute, "POST");
        
        // 在 URL 后添加 _method 参数
        QUrlQuery query(requestUrl.query());
        query.addQueryItem("_method", upperMethod);
        requestUrl.setQuery(query);
    } else if (upperMethod == "POST") {
        request.setAttribute(QNetworkRequest::CustomVerbAttribute, "POST");
    }
    // GET 方法不需要特殊设置，使用默认的 GET
    
    request.setUrl(requestUrl);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
    request.setRawHeader("Accept", "application/json");
    
    // 设置 User-Agent，如果没有提供则使用默认值
    if (!userAgent.isEmpty()) {
        request.setRawHeader("User-Agent", userAgent.toUtf8());
    } else {
        request.setRawHeader("User-Agent", "BaseCommand/1.0");
    }
    
    return request;
}

QString BaseCommand::getBaseUrl() const
{
    if (!m_backendService) {
        return QString();
    }
    
    // 获取 baseUrl（通过 loadServerHost 方法）
    QString baseUrl = m_backendService->loadServerHost();
    if (baseUrl.isEmpty()) {
        // 如果 loadServerHost 返回空，尝试直接从设置文件读取
        QString homePath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
        if (!homePath.isEmpty()) {
            QString settingsPath = QDir(homePath).filePath(".myapps/setting.ini");
            if (QFile::exists(settingsPath)) {
                QSettings settings(settingsPath, QSettings::IniFormat);
                baseUrl = settings.value("Server/Host", "").toString();
            }
        }
        // 如果还是为空，使用默认值
        if (baseUrl.isEmpty()) {
            baseUrl = "http://localhost:8888"; // 默认值
        }
    }
    
    return baseUrl;
}

bool BaseCommand::ensureAccessToken()
{
    if (!m_backendService) {
        qDebug() << "BaseCommand: BackendService 未设置";
        return false;
    }
    
    // 检查是否有accessToken
    QString accessToken = CommandExecutor::getAccessToken();
    if (accessToken.isEmpty()) {
        // 获取 CommandExecutor 实例
        CommandExecutor *commandExecutor = m_backendService->getCommandExecutor();
        if (!commandExecutor) {
            qDebug() << "BaseCommand: CommandExecutor 未设置，无法获取accessToken";
            return false;
        }
        
        qDebug() << "BaseCommand: 没有accessToken，先获取accessToken";
        m_isWaitingForToken = true;
        // 通过 CommandExecutor 调用 exchangeAccessToken（domainId 将在方法内部获取）
        commandExecutor->executeExchangeAccessToken();
        // 返回 false 表示正在获取 token
        return false;
    }
    
    // 返回 true 表示已有 accessToken
    return true;
}

bool BaseCommand::isValid() const
{
    return m_backendService != nullptr && m_networkManager != nullptr;
}

void BaseCommand::handleExchangeAccessTokenCompleted(int resultCode, const QString &message, const QString &accessToken)
{
    // 只有在等待 token 时才处理
    if (!m_isWaitingForToken) {
        return;
    }
    
    // 立即重置等待状态，避免重复处理
    m_isWaitingForToken = false;
    
    // 安全检查 - 检查对象是否仍然有效
    if (!isValid()) {
        qDebug() << "BaseCommand: 对象已被销毁，无法继续执行";
        return;
    }
    
    // AccessToken 获取完成，但不再调用子类方法
    Q_UNUSED(resultCode);
    Q_UNUSED(message);
    Q_UNUSED(accessToken);
}

